// API配置
// 智能检测环境并配置API基础URL
const getAPIBaseURL = () => {
    // 如果是开发模式（通过端口号判断），使用代理路径
    if (window.location.port === '3000') {
        return '/api'  // 开发环境使用代理
    }

    // 如果是文件协议（本地文件）
    if (window.location.protocol === 'file:') {
        return 'http://localhost:10001/api'
    }

    // 生产环境（打包后的静态文件）
    return `${window.location.protocol}//${window.location.host}/api`
}

const getWSBaseURL = () => {
    // 如果是开发模式，使用代理路径
    if (window.location.port === '3000') {
        return '/ws'  // 开发环境使用代理
    }

    // 如果是文件协议
    if (window.location.protocol === 'file:') {
        return 'ws://localhost:10001/ws'
    }

    // 生产环境
    return `${window.location.protocol.replace('http', 'ws')}//${window.location.host}/ws`
}

const API_BASE_URL = getAPIBaseURL()
const WS_BASE_URL = getWSBaseURL()

console.log('API Base URL:', API_BASE_URL)
console.log('WebSocket Base URL:', WS_BASE_URL)

// HTTP请求封装
async function apiRequest(url, options = {}) {
    const response = await fetch(`${API_BASE_URL}${url}`, {
        headers: {
            'Content-Type': 'application/json',
            ...options.headers
        },
        ...options
    })

    if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
    }

    return await response.json()
}

// 网络相关API
export const netApi = {
    // 建立网络连接
    async connect(config) {
        return await apiRequest('/net/connect', {
            method: 'POST',
            body: JSON.stringify(config)
        })
    },

    // 断开网络连接
    async disconnect(connectionId) {
        return await apiRequest(`/net/disconnect/${connectionId}`, {
            method: 'POST'
        })
    },

    // 发送网络数据
    async sendData(connectionId, data, format = 'text') {
        // 验证参数
        if (!connectionId) {
            throw new Error('连接ID不能为空')
        }
        if (data === undefined || data === null) {
            throw new Error('发送数据不能为空')
        }

        const requestData = {
            data: String(data || ''),  // 确保数据为字符串
            format: format || 'text'
        }

        console.log('API发送数据:', { connectionId, requestData })

        return await apiRequest(`/net/send/${connectionId}`, {
            method: 'POST',
            body: JSON.stringify(requestData)
        })
    },

    // 获取网络连接状态
    async getStatus(connectionId) {
        return await apiRequest(`/net/status/${connectionId}`)
    },

    // 创建WebSocket连接
    createWebSocket(connectionId, onMessage, onClose, onError) {
        // WS_BASE_URL在所有环境下都已经包含'/ws'前缀
        // 所以这里直接使用'/net/{connectionId}'，组合后为'/ws/net/{connectionId}'
        const wsUrl = `${WS_BASE_URL}/net/${connectionId}`
        console.log(`正在建立WebSocket连接: ${wsUrl}`)
        
        // 包装错误处理函数以提供更多信息
        const enhancedOnError = (error) => {
            console.error(`WebSocket连接错误 (${wsUrl}):`, error)
            onError && onError(error)
        }
        
        const enhancedOnClose = (event) => {
            console.log(`WebSocket连接已关闭 (${wsUrl}):`, {
                code: event.code,
                reason: event.reason,
                wasClean: event.wasClean
            })
            onClose && onClose(event)
        }
        
        try {
            const ws = new WebSocket(wsUrl)
            
            // 添加连接状态监听
            ws.onopen = () => {
                console.log(`WebSocket连接已成功建立: ${wsUrl}`)
            }

            ws.onmessage = (event) => {
                try {
                    const data = JSON.parse(event.data)
                    console.log('WebSocket收到消息:', data)
                    onMessage && onMessage(data)
                } catch (error) {
                    console.error('WebSocket消息解析错误:', error, '原始消息:', event.data)
                }
            }

            ws.onclose = enhancedOnClose
            ws.onerror = enhancedOnError

            return ws
        } catch (error) {
            console.error('创建WebSocket实例失败:', error)
            enhancedOnError(error)
            throw error
        }
    }
}

// 系统配置API
export const systemApi = {
    // 获取端口配置
    async getPortConfig() {
        return await apiRequest('/system/config/port')
    },

    // 更新端口配置
    async updatePortConfig(port) {
        return await apiRequest('/system/config/port', {
            method: 'POST',
            body: JSON.stringify({ port })
        })
    },

    // 重启服务
    async restartService() {
        return await apiRequest('/system/restart', {
            method: 'POST'
        })
    },

    // 获取系统信息
    async getSystemInfo() {
        return await apiRequest('/system/info')
    }
}

// 串口相关API
export const serialApi = {
    // 获取可用串口列表
    async getPorts() {
        return await apiRequest('/serial/ports')
    },

    // 打开串口连接
    async connect(config) {
        return await apiRequest('/serial/connect', {
            method: 'POST',
            body: JSON.stringify(config)
        })
    },

    // 关闭串口连接
    async disconnect(port) {
        return await apiRequest(`/serial/disconnect/${port}`, {
            method: 'POST'
        })
    },

    // 发送串口数据
    async sendData(port, data, format = 'text') {
        // 验证参数
        if (!port) {
            throw new Error('串口不能为空')
        }
        if (data === undefined || data === null) {
            throw new Error('发送数据不能为空')
        }

        const requestData = {
            data: String(data || ''),  // 确保数据为字符串
            format: format || 'text'
        }

        return await apiRequest(`/serial/send/${port}`, {
            method: 'POST',
            body: JSON.stringify(requestData)
        })
    },

    // 获取串口连接状态
    async getStatus(port) {
        return await apiRequest(`/serial/status/${port}`)
    },

    // 创建WebSocket连接
    createWebSocket(port, onMessage, onClose, onError) {
        const ws = new WebSocket(`${WS_BASE_URL}/serial/${port}`)

        ws.onmessage = (event) => {
            try {
                const data = JSON.parse(event.data)
                onMessage && onMessage(data)
            } catch (error) {
                console.error('WebSocket消息解析错误:', error)
            }
        }

        ws.onclose = onClose
        ws.onerror = onError

        return ws
    }
}